The Complexity of Order Type Isomorphism

The order type of a point set in Rd maps a (d+1)-tuple of points to its orientation (e.g., clockwise or counterclockwise in R2). Two point sets X and Y have the same order type if there exists a mapping f from X to Y for which every (d+1)-tuple (a1, a2, . . . , ad+1) of X and the corresponding tuple (f(a1), f(a2), . . . , f(ad+1)) in Y have the same orientation. In this paper we investigate the complexity of determining whether two point sets have the same order type. We provide an O(nd) algorithm for this task, thereby improving upon the O(nb3d/2c) algorithm of Goodman and Pollack (1983). The algorithm uses only order type queries and also works for abstract order types (or acyclic oriented matroids). Since there are 2Ω(n d) different abstract order types, our algorithm is optimal in the abstract setting by the information theory lower bound. However the number of realizable order types (i.e. corresponding to actual sets of points) is much smaller; at most 2O(n logn). However, it was shown in [4] that Ω(nd) order type queries are required to determine if two realizable order types are identical, thereby proving our algorithm is optimal even in that case. Introduction. In the design of geometric algorithms, as well as in their practical implementation, it is often convenient to encapsulate the geometry of a given problem into a small set of elementary geometric predicates. A typical example, ubiquitous in computational geometry textbooks, is the left turn / right turn determinant whose sign determines if three points a, b, c ∈ R2 are in clockwise or counterclockwise orientation, or collinear, respectively. The practical motivation for this encapsulation will be obvious to any programmer: by restricting the use of arithmetic operations to just one place in the code, it is easier to control the robustness of the code. It is also easier to generalize the code should a different geometric space require a slightly different 1 Chargé de recherches du F.R.S.-FNRS, Département d’Informatique, Université Libre de Bruxelles, [email protected] 2 Department of Computer Science and Engineering, Polytechnic Institute of New York University, [email protected], [email protected] 3 Directeur de Recherches du F.R.S.-FNRS, Département d’Informatique, Université Libre de Bruxelles, [email protected] 4 Cluster of Excellence MMCI, Saarland University, [email protected] implementation of the predicate (e.g. solving geometric problems on a sphere or in a polygon). This would require a proper abstraction to generalize the predicate ∇ to other applications. The need for a classification or discretization of planar point sets became evident long before computers were invented. In 1882, Perrin [10] described how a point moving on a line far enough from a collection of points sees the points under a sequence of ( n 2 ) different radial orders, each produced by swapping two adjacent labels from the previous ordering. He then showed how this representation can be used to solve problems without the use of the original point set. This view of point configurations was revived and characterized under the name of allowable sequences by Goodman and Pollack in 1980 [5]. They later showed how the same allowable sequences can describe pseudoline arrangements [7]. The classification of point sets induced by the determinant ∇ above, but generalized to d dimensions, was discovered around the same time. Consider a set P = {p1, . . . , pn} ⊆ Rd, let pi = (xi,1, . . . , xi,d) and for ease of notation let xi,0 = 1. The order type of P is characterized by the predicate5 ∇P (i0, i1, . . . , id) = ∇(pi0 , . . . , pid) = sign(det(pi0 , . . . , pid)), for all {i0, . . . , id} ∈ [n]. This concept appeared independently in various contexts over a span of 15 years, under various names, e.g., n-ordered sets [9], multiplex [2], chirotope [3], order type [6], among others inspired by problems from chemistry. For some of them (e.g., chirotopes or abstract order types), the precise algebraic definition above is replaced by a set of axioms that the predicate ∇P must satisfy. In the early 90’s Knuth [8] revisited once more the axiomatic system of chirotopes under the name of CC-systems, but this time with a specific focus on computational aspects, mainly, what predicates and axioms are necessary in order to compute a convex hull (and later a Delaunay triangulation), and what running times can be obtained by an algorithm using only those predicates. The theory of oriented matroids appeared in the mid ’70s. Their primary purpose was to provide an abstraction of linear dependency. However, through their various equivalent axiomatizations they have been used to show a translation between virtually all abstractions mentioned above. We write [n] to denote the set of integers {1, . . . , n}. Isomorphism is probably one of the most fundamental problems for any discrete structure. In our setting, two (abstract) order types with predicates ∇P and ∇Q are isomorphic if there is a permutation π such that ∇P (i0, . . . , id) = ∇(π(i0), . . . , π(id)) for all {i0, . . . , id} ∈ [n], or more succinctly,∇P = ∇Q ◦ π. Given a labeled point set P , an Order Type Representation (OTR) is a functionE that only depends on ∇P and encodes the order type as a string, meaning that using that string, the orientation ∇P (i0, . . . , id) of every d+1-tuple can be retrieved. We will write E(P ) = E(∇P ) for that string. In 1983, Goodman and Pollack [6] implicitly defined an encoding of size O(nd) which lists for every d-tuple of integers (i1, . . . , id) the number of values i0 for which ∇P (i0, . . . , id) = +. They showed that these values suffice to retrieve the value of ∇P for every d+1tuple. One strategy for identifying whether P and Q have the same order type is to fix a labeling of P , try every possible labeling for Q, and compare their OTRs, that is, to check whether E(∇P ) = E(∇Q ◦ π) for any permutation π. In [6] it was shown that for comparing two order types, it suffices to look at a reduced set of canonical labelings. In R2 these are produced by listing all points in counterclockwise order from some point on the convex hull of P . In Rd, labelings are generated by convex hull flags. Thus there are at most O(h) = O(nbd/2c) canonical orderings where h is the number of flags on the convex hull of the sets. Using this observation, and the fact that their OTR is of length O(nd), it was shown in [6] that the equality of two order types can be determined in O(hnd) = O(nb3d/2c) time. That running time has not been improved for arbitrary d. For R3 an improvement to O(n3 log n) has been given for points in general position [1]. Automorphisms and canonical labelings. The isomorphism problem is naturally connected to the automorphism problem, which is to determine the group of permutations π such that ∇P = ∇P ◦ π. One common technique to discover automorphisms is through the use of canonical labelings. A canonical labeling ρ∗(∇P ) for an order type with predicate ∇P is a permutation such that ρ∗(∇P ) = ρ∗(∇P ◦π) for any permutation π. One way of producing such a labeling is to pick ρ∗ (possibly among a reduced set, as done by Goodman and Pollack) as the labeling that produces the representation E(∇P ◦ ρ∗) that is lexicographically minimum (abbreviated as “MinLex” later on). Then, the automorphism group of the order type is just the set of permutations ρ such that E(∇P ◦ρ) = E(∇P ◦ρ∗). Of course, using a canonical labeling it is easy to solve the isomorphism problem as it is sufficient to check whether the canonical representations of the two order types match. It is worth noting that the canonical labeling problem could potentially be harder than that of isomorphism. For instance, in the case of graphs, finding a canonical labeling is NP-complete. Our results. We present the first O(nd)-time algorithm for producing a canonical labeling and the automorphism group of an order type. Consequently the algorithm can also be used to determine if two order types are isomorphic. The algorithm works for any d ≥ 2 and does not assume general position. It uses no other information than what is given by the order type predicate (used as an oracle), and works for abstract order types, or acyclic oriented matroids of rank d+1.